package solutions.ferpa.ztest.intf;

import br.com.telescope.adsrt.dom.DomFlag;
import br.com.telescope.adsrt.dom.DomId;
import br.com.telescope.adsrt.dom.DomPercent;
import br.com.telescope.adsrt.dom.DomUpper;
import br.com.telescope.t2.ServiceModel;
import br.com.telescope.t2.feature.AbstractFeature;
import br.com.telescope.t2.feature.DeleteFeature;
import br.com.telescope.t2.feature.ListFeature;
import br.com.telescope.t2.feature.MultiRowInsertFeature;
import br.com.telescope.t2.feature.MultiRowUpdateFeature;
import br.com.telescope.t2.feature.QueryFeature;
import br.com.telescope.t2.feature.ViewFeature;
import solutions.ferpa.ztest.ent.*;
import solutions.ferpa.ztest.intf.*;

/**
 * Critérios de aprovações nos ensaios.
 * <p>
 * Interface para manutenção de Critério de aprovação no ensaio
 * <P>
 * Telescope origin: ZTEST.CAD_CRITERIO_APROVACAO_ENSAIO
 * <P>
 * Base entity: ZTEST.CRITERIO_APROVACAO_ENSAIO
 * <P>
 * @author TELESCOPE - Build task T2 Web Interface Generator
 * <P>
 * @version 0.1
 */
public class CadCriterioAprovacaoEnsaio extends ServiceModel {
    
    // <editor-fold defaultstate="collapsed" desc="Generated Code">
    public static final String GLOBAL_NAME = "ZTEST.CAD_CRITERIO_APROVACAO_ENSAIO";
    
    @Override
    public String globalName() {
        return GLOBAL_NAME;
    }
    
    {
        setTitle("Critérios de aprovações nos ensaios");
    }
    
    protected EntCriterioAprovacaoEnsaio base;
    protected EntCriterioAprovacaoEnsaio rec; // NEED_TJW1_COMPATIBILITY
    
    // Record items
    private DomUpper aNome;
    private DomPercent aPercentualErroMinimoInferior;
    private DomPercent aPercentualErroMaximoInferior;
    private DomPercent aPercentualErroMinimoSuperior;
    private DomPercent aPercentualErroMaximoSuperior;
    private DomFlag aExigeSinalDiferente;
    private DomId aId;
    
    // Query items
    private DomFlag qExigeSinalDiferente;
    private DomPercent qPercentualErroMinimoInferior;
    private DomPercent qPercentualErroMaximoSuperior;
    private DomPercent qPercentualErroMinimoSuperior;
    private DomPercent qPercentualErroMaximoInferior;
    private DomUpper qNome;
    
    @Override
    public String getBaseSql() {
        return "select BASE.*"
                + " from CRITERIO_APROVACAO_ENSAIO BASE";
    }
    
    @Override
    public void initAttributes() {
        
        aNome = new DomUpper();
        aNome.context(ctx).name("NOME").label("Nome do critério de aprovação");
        
        aPercentualErroMinimoInferior = new DomPercent();
        aPercentualErroMinimoInferior.context(ctx).name("PERCENTUAL_ERRO_MINIMO_INFERIOR").label("% de erro mínimo (campo inferior)");
        
        aPercentualErroMaximoInferior = new DomPercent();
        aPercentualErroMaximoInferior.context(ctx).name("PERCENTUAL_ERRO_MAXIMO_INFERIOR").label("% de erro máximo (campo inferior)");
        
        aPercentualErroMinimoSuperior = new DomPercent();
        aPercentualErroMinimoSuperior.context(ctx).name("PERCENTUAL_ERRO_MINIMO_SUPERIOR").label("% de erro mínimo (campo superior)");
        
        aPercentualErroMaximoSuperior = new DomPercent();
        aPercentualErroMaximoSuperior.context(ctx).name("PERCENTUAL_ERRO_MAXIMO_SUPERIOR").label("% de erro máximo (campo superior)");
        
        aExigeSinalDiferente = new DomFlag();
        aExigeSinalDiferente.context(ctx).name("EXIGE_SINAL_DIFERENTE").label("Exige percentual de erro com sinal distinto");
        aExigeSinalDiferente.setDefaultValue("S");
        
        aId = new DomId();
        aId.context(ctx).name("ID").label("Id");
        
        
        qExigeSinalDiferente = new DomFlag();
        qExigeSinalDiferente.context(ctx).name("EXIGE_SINAL_DIFERENTE").label("Exige percentual de erro com sinal distinto");
        
        qPercentualErroMinimoInferior = new DomPercent();
        qPercentualErroMinimoInferior.context(ctx).name("PERCENTUAL_ERRO_MINIMO_INFERIOR").label("% de erro mínimo (campo inferior)");
        
        qPercentualErroMaximoSuperior = new DomPercent();
        qPercentualErroMaximoSuperior.context(ctx).name("PERCENTUAL_ERRO_MAXIMO_SUPERIOR").label("% de erro máximo (campo superior)");
        
        qPercentualErroMinimoSuperior = new DomPercent();
        qPercentualErroMinimoSuperior.context(ctx).name("PERCENTUAL_ERRO_MINIMO_SUPERIOR").label("% de erro mínimo (campo superior)");
        
        qPercentualErroMaximoInferior = new DomPercent();
        qPercentualErroMaximoInferior.context(ctx).name("PERCENTUAL_ERRO_MAXIMO_INFERIOR").label("% de erro máximo (campo inferior)");
        
        qNome = new DomUpper();
        qNome.context(ctx).name("NOME").label("Nome do critério de aprovação");
    }
    
    @Override
    public String getQueryPkColumn() {
        return "BASE.ID";
    }
    
    @Override
    public void setId(String value) {
        this.aId.setValue(value);
    }
    
    @Override
    public EntCriterioAprovacaoEnsaio getRecord() {
        if (base == null) {
            base = new EntCriterioAprovacaoEnsaio(ctx);
            rec = base;
        }
        return this.base;
    }
    
    @Override
    public String getContextName() {
        return aNome.toText();
    }
    
    @Override
    public String getDefaultOrderBy() {
        return "NOME, PERCENTUAL_ERRO_MINIMO_INFERIOR, PERCENTUAL_ERRO_MAXIMO_INFERIOR, PERCENTUAL_ERRO_MINIMO_SUPERIOR";
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="QUERY">
    public class FQuery extends QueryFeature {
        
        @Override
        public void initForm() {
            addField(qNome, "opt");
            addField(qPercentualErroMinimoInferior, "opt");
            addField(qPercentualErroMaximoInferior, "opt");
            addField(qPercentualErroMinimoSuperior, "opt");
            addField(qPercentualErroMaximoSuperior, "opt");
            addField(qExigeSinalDiferente, "opt");
        }
        
        {
            setFeatureName("QUERY");
            setPrimary(false);
        }
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="LIST">
    public class FList extends ListFeature {
        
        @Override
        public void initForm() {
            addField(aNome, "view");
            addField(aPercentualErroMinimoInferior, "view");
            addField(aPercentualErroMaximoInferior, "view");
            addField(aPercentualErroMinimoSuperior, "view");
            addField(aPercentualErroMaximoSuperior, "view");
            addField(aExigeSinalDiferente, "view");
        }
        
        {
            setFeatureName("LIST");
            setPrimary(false);
        }
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="VIEW">
    public class FView extends ViewFeature {
        
        @Override
        public void initForm() {
            addField(aNome, "view");
            addField(aPercentualErroMinimoInferior, "view");
            addField(aPercentualErroMaximoInferior, "view");
            addField(aPercentualErroMinimoSuperior, "view");
            addField(aPercentualErroMaximoSuperior, "view");
            addField(aExigeSinalDiferente, "view");
        }
        
        @Override
        public void posDisplay() {
            {
                ConPlanosEnsaioCriterio external = new ConPlanosEnsaioCriterio();
                external.setRuntime(ctx.clone());
                external.init();
                AbstractFeature feature = external.getFeature("LIST");
                external.setParameterIdCriterioAprovacao(aId.getValue());
                external.setDetail(true);
                feature.run();
            }
        }
        
        {
            setFeatureName("VIEW");
            setPrimary(false);
        }
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="INSERT">
    public class FInsert extends MultiRowInsertFeature {
        
        @Override
        public void initForm() {
            aNome.setOptional(false);
            addField(aNome, "rqd");
            aPercentualErroMinimoInferior.setOptional(false);
            addField(aPercentualErroMinimoInferior, "rqd");
            aPercentualErroMaximoInferior.setOptional(false);
            addField(aPercentualErroMaximoInferior, "rqd");
            aPercentualErroMinimoSuperior.setOptional(false);
            addField(aPercentualErroMinimoSuperior, "rqd");
            aPercentualErroMaximoSuperior.setOptional(false);
            addField(aPercentualErroMaximoSuperior, "rqd");
            aExigeSinalDiferente.setOptional(false);
            addField(aExigeSinalDiferente, "rqd");
        }
        
        {
            setFeatureName("INSERT");
            setPrimary(false);
            setRows(10);
        }
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="UPDATE">
    public class FUpdate extends MultiRowUpdateFeature {
        
        @Override
        public void initForm() {
            aNome.setLabel("Crit. aprovação");
            aNome.setOptional(false);
            addField(aNome, "rqd");
            aPercentualErroMinimoInferior.setLabel("% erro mínimo (inferior)");
            aPercentualErroMinimoInferior.setOptional(false);
            addField(aPercentualErroMinimoInferior, "rqd");
            aPercentualErroMaximoInferior.setLabel("% erro máxímo (inferior)");
            aPercentualErroMaximoInferior.setOptional(false);
            addField(aPercentualErroMaximoInferior, "rqd");
            aPercentualErroMinimoSuperior.setLabel("% erro mínimo (superior)");
            aPercentualErroMinimoSuperior.setOptional(false);
            addField(aPercentualErroMinimoSuperior, "rqd");
            aPercentualErroMaximoSuperior.setLabel("% erro máxímo (superior)");
            aPercentualErroMaximoSuperior.setOptional(false);
            addField(aPercentualErroMaximoSuperior, "rqd");
            aExigeSinalDiferente.setOptional(false);
            addField(aExigeSinalDiferente, "rqd");
        }
        
        {
            setFeatureName("UPDATE");
            setPrimary(false);
            setRows(10);
        }
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="DELETE">
    public class FDelete extends DeleteFeature {
        
        @Override
        public void initForm() {
            addField(aNome, "view");
        }
        
        {
            setFeatureName("DELETE");
            setPrimary(false);
        }
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="initFeatures">
    
    @Override
    protected void initFeatures() {
        addFeature(new FQuery());
        addFeature(new FList());
        addFeature(new FView());
        addFeature(new FInsert());
        addFeature(new FUpdate());
        addFeature(new FDelete());
        super.initFeatures();
    }
    
    @Override
    public String getDefaultFeature() {
        return "QUERY";
    }
    // </editor-fold>
    
    // <editor-fold defaultstate="collapsed" desc="Getters and Setters">
    
    public String getNome() {
        return aNome.getValue();
    }
    
    public void setNome(String value) {
        this.aNome.setValue(value);
    }
    
    public Double getPercentualErroMinimoInferior() {
        return aPercentualErroMinimoInferior.getValue();
    }
    
    public void setPercentualErroMinimoInferior(Double value) {
        this.aPercentualErroMinimoInferior.setValue(value);
    }
    
    public Double getPercentualErroMaximoInferior() {
        return aPercentualErroMaximoInferior.getValue();
    }
    
    public void setPercentualErroMaximoInferior(Double value) {
        this.aPercentualErroMaximoInferior.setValue(value);
    }
    
    public Double getPercentualErroMinimoSuperior() {
        return aPercentualErroMinimoSuperior.getValue();
    }
    
    public void setPercentualErroMinimoSuperior(Double value) {
        this.aPercentualErroMinimoSuperior.setValue(value);
    }
    
    public Double getPercentualErroMaximoSuperior() {
        return aPercentualErroMaximoSuperior.getValue();
    }
    
    public void setPercentualErroMaximoSuperior(Double value) {
        this.aPercentualErroMaximoSuperior.setValue(value);
    }
    
    public String getExigeSinalDiferente() {
        return aExigeSinalDiferente.getValue();
    }
    
    public void setExigeSinalDiferente(String value) {
        this.aExigeSinalDiferente.setValue(value);
    }
    
    @Override
    public Long getId() {
        return aId.getValue();
    }
    
    public void setId(Long value) {
        this.aId.setValue(value);
    }
    public String getQueryNome() {
        return qNome.getQueryValue();
    }
    
    public void setQueryNome(String value) {
        this.qNome.setQueryValue(value);
    }
    public String getQueryPercentualErroMinimoInferior() {
        return qPercentualErroMinimoInferior.getQueryValue();
    }
    
    public void setQueryPercentualErroMinimoInferior(String value) {
        this.qPercentualErroMinimoInferior.setQueryValue(value);
    }
    public String getQueryPercentualErroMaximoInferior() {
        return qPercentualErroMaximoInferior.getQueryValue();
    }
    
    public void setQueryPercentualErroMaximoInferior(String value) {
        this.qPercentualErroMaximoInferior.setQueryValue(value);
    }
    public String getQueryPercentualErroMinimoSuperior() {
        return qPercentualErroMinimoSuperior.getQueryValue();
    }
    
    public void setQueryPercentualErroMinimoSuperior(String value) {
        this.qPercentualErroMinimoSuperior.setQueryValue(value);
    }
    public String getQueryPercentualErroMaximoSuperior() {
        return qPercentualErroMaximoSuperior.getQueryValue();
    }
    
    public void setQueryPercentualErroMaximoSuperior(String value) {
        this.qPercentualErroMaximoSuperior.setQueryValue(value);
    }
    public String getQueryExigeSinalDiferente() {
        return qExigeSinalDiferente.getQueryValue();
    }
    
    public void setQueryExigeSinalDiferente(String value) {
        this.qExigeSinalDiferente.setQueryValue(value);
    }
    // </editor-fold>
    
}
